home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / popen2.py < prev    next >
Text File  |  2005-10-18  |  9KB  |  225 lines
  1. """Spawn a command with pipes to its stdin, stdout, and optionally stderr.
  2.  
  3. The normal os.popen(cmd, mode) call spawns a shell command and provides a
  4. file interface to just the input or output of the process depending on
  5. whether mode is 'r' or 'w'.  This module provides the functions popen2(cmd)
  6. and popen3(cmd) which return two or three pipes to the spawned command.
  7. """
  8.  
  9. import os
  10. import sys
  11.  
  12. __all__ = ["popen2", "popen3", "popen4"]
  13.  
  14. try:
  15.     MAXFD = os.sysconf('SC_OPEN_MAX')
  16. except (AttributeError, ValueError):
  17.     MAXFD = 256
  18.  
  19. _active = []
  20.  
  21. def _cleanup():
  22.     for inst in _active[:]:
  23.         inst.poll()
  24.  
  25. class Popen3:
  26.     """Class representing a child process.  Normally instances are created
  27.     by the factory functions popen2() and popen3()."""
  28.  
  29.     sts = -1                    # Child not completed yet
  30.  
  31.     def __init__(self, cmd, capturestderr=False, bufsize=-1):
  32.         """The parameter 'cmd' is the shell command to execute in a
  33.         sub-process.  On UNIX, 'cmd' may be a sequence, in which case arguments
  34.         will be passed directly to the program without shell intervention (as
  35.         with os.spawnv()).  If 'cmd' is a string it will be passed to the shell
  36.         (as with os.system()).   The 'capturestderr' flag, if true, specifies
  37.         that the object should capture standard error output of the child
  38.         process.  The default is false.  If the 'bufsize' parameter is
  39.         specified, it specifies the size of the I/O buffers to/from the child
  40.         process."""
  41.         _cleanup()
  42.         p2cread, p2cwrite = os.pipe()
  43.         c2pread, c2pwrite = os.pipe()
  44.         if capturestderr:
  45.             errout, errin = os.pipe()
  46.         self.pid = os.fork()
  47.         if self.pid == 0:
  48.             # Child
  49.             os.dup2(p2cread, 0)
  50.             os.dup2(c2pwrite, 1)
  51.             if capturestderr:
  52.                 os.dup2(errin, 2)
  53.             self._run_child(cmd)
  54.         os.close(p2cread)
  55.         self.tochild = os.fdopen(p2cwrite, 'w', bufsize)
  56.         os.close(c2pwrite)
  57.         self.fromchild = os.fdopen(c2pread, 'r', bufsize)
  58.         if capturestderr:
  59.             os.close(errin)
  60.             self.childerr = os.fdopen(errout, 'r', bufsize)
  61.         else:
  62.             self.childerr = None
  63.         _active.append(self)
  64.  
  65.     def _run_child(self, cmd):
  66.         if isinstance(cmd, basestring):
  67.             cmd = ['/bin/sh', '-c', cmd]
  68.         for i in range(3, MAXFD):
  69.             try:
  70.                 os.close(i)
  71.             except OSError:
  72.                 pass
  73.         try:
  74.             os.execvp(cmd[0], cmd)
  75.         finally:
  76.             os._exit(1)
  77.  
  78.     def poll(self):
  79.         """Return the exit status of the child process if it has finished,
  80.         or -1 if it hasn't finished yet."""
  81.         if self.sts < 0:
  82.             try:
  83.                 pid, sts = os.waitpid(self.pid, os.WNOHANG)
  84.                 if pid == self.pid:
  85.                     self.sts = sts
  86.                     _active.remove(self)
  87.             except os.error:
  88.                 pass
  89.         return self.sts
  90.  
  91.     def wait(self):
  92.         """Wait for and return the exit status of the child process."""
  93.         if self.sts < 0:
  94.             pid, sts = os.waitpid(self.pid, 0)
  95.             if pid == self.pid:
  96.                 self.sts = sts
  97.                 _active.remove(self)
  98.         return self.sts
  99.  
  100.  
  101. class Popen4(Popen3):
  102.     childerr = None
  103.  
  104.     def __init__(self, cmd, bufsize=-1):
  105.         _cleanup()
  106.         p2cread, p2cwrite = os.pipe()
  107.         c2pread, c2pwrite = os.pipe()
  108.         self.pid = os.fork()
  109.         if self.pid == 0:
  110.             # Child
  111.             os.dup2(p2cread, 0)
  112.             os.dup2(c2pwrite, 1)
  113.             os.dup2(c2pwrite, 2)
  114.             self._run_child(cmd)
  115.         os.close(p2cread)
  116.         self.tochild = os.fdopen(p2cwrite, 'w', bufsize)
  117.         os.close(c2pwrite)
  118.         self.fromchild = os.fdopen(c2pread, 'r', bufsize)
  119.         _active.append(self)
  120.  
  121.  
  122. if sys.platform[:3] == "win" or sys.platform == "os2emx":
  123.     # Some things don't make sense on non-Unix platforms.
  124.     del Popen3, Popen4
  125.  
  126.     def popen2(cmd, bufsize=-1, mode='t'):
  127.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  128.         be a sequence, in which case arguments will be passed directly to the
  129.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  130.         string it will be passed to the shell (as with os.system()). If
  131.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  132.         file objects (child_stdout, child_stdin) are returned."""
  133.         w, r = os.popen2(cmd, mode, bufsize)
  134.         return r, w
  135.  
  136.     def popen3(cmd, bufsize=-1, mode='t'):
  137.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  138.         be a sequence, in which case arguments will be passed directly to the
  139.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  140.         string it will be passed to the shell (as with os.system()). If
  141.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  142.         file objects (child_stdout, child_stdin, child_stderr) are returned."""
  143.         w, r, e = os.popen3(cmd, mode, bufsize)
  144.         return r, w, e
  145.  
  146.     def popen4(cmd, bufsize=-1, mode='t'):
  147.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  148.         be a sequence, in which case arguments will be passed directly to the
  149.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  150.         string it will be passed to the shell (as with os.system()). If
  151.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  152.         file objects (child_stdout_stderr, child_stdin) are returned."""
  153.         w, r = os.popen4(cmd, mode, bufsize)
  154.         return r, w
  155. else:
  156.     def popen2(cmd, bufsize=-1, mode='t'):
  157.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  158.         be a sequence, in which case arguments will be passed directly to the
  159.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  160.         string it will be passed to the shell (as with os.system()). If
  161.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  162.         file objects (child_stdout, child_stdin) are returned."""
  163.         inst = Popen3(cmd, False, bufsize)
  164.         return inst.fromchild, inst.tochild
  165.  
  166.     def popen3(cmd, bufsize=-1, mode='t'):
  167.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  168.         be a sequence, in which case arguments will be passed directly to the
  169.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  170.         string it will be passed to the shell (as with os.system()). If
  171.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  172.         file objects (child_stdout, child_stdin, child_stderr) are returned."""
  173.         inst = Popen3(cmd, True, bufsize)
  174.         return inst.fromchild, inst.tochild, inst.childerr
  175.  
  176.     def popen4(cmd, bufsize=-1, mode='t'):
  177.         """Execute the shell command 'cmd' in a sub-process. On UNIX, 'cmd' may
  178.         be a sequence, in which case arguments will be passed directly to the
  179.         program without shell intervention (as with os.spawnv()). If 'cmd' is a
  180.         string it will be passed to the shell (as with os.system()). If
  181.         'bufsize' is specified, it sets the buffer size for the I/O pipes. The
  182.         file objects (child_stdout_stderr, child_stdin) are returned."""
  183.         inst = Popen4(cmd, bufsize)
  184.         return inst.fromchild, inst.tochild
  185.  
  186.     __all__.extend(["Popen3", "Popen4"])
  187.  
  188. def _test():
  189.     cmd  = "cat"
  190.     teststr = "ab cd\n"
  191.     if os.name == "nt":
  192.         cmd = "more"
  193.     # "more" doesn't act the same way across Windows flavors,
  194.     # sometimes adding an extra newline at the start or the
  195.     # end.  So we strip whitespace off both ends for comparison.
  196.     expected = teststr.strip()
  197.     print "testing popen2..."
  198.     r, w = popen2(cmd)
  199.     w.write(teststr)
  200.     w.close()
  201.     got = r.read()
  202.     if got.strip() != expected:
  203.         raise ValueError("wrote %r read %r" % (teststr, got))
  204.     print "testing popen3..."
  205.     try:
  206.         r, w, e = popen3([cmd])
  207.     except:
  208.         r, w, e = popen3(cmd)
  209.     w.write(teststr)
  210.     w.close()
  211.     got = r.read()
  212.     if got.strip() != expected:
  213.         raise ValueError("wrote %r read %r" % (teststr, got))
  214.     got = e.read()
  215.     if got:
  216.         raise ValueError("unexpected %r on stderr" % (got,))
  217.     for inst in _active[:]:
  218.         inst.wait()
  219.     if _active:
  220.         raise ValueError("_active not empty")
  221.     print "All OK"
  222.  
  223. if __name__ == '__main__':
  224.     _test()
  225.